home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / The World of Computer Software.iso / netbon.zip / NETBIND.INC < prev    next >
Text File  |  1991-11-25  |  22KB  |  880 lines
  1. {
  2.   NETBIND.INC 1.1
  3. }
  4. function AddObjectToSet(ObjType : Word; ObjName : ObjNameStr;
  5.                         PropertyName : PropertyStr;
  6.                         MemberObjType : Word;
  7.                         MemberObjName : ObjNameStr) : Byte;
  8.  
  9. var
  10.   RequestBuffer : record
  11.                     Len     : Word;
  12.                     SubF    : Byte;
  13.                     ObjT    : Word;
  14.                     Buf     : Array[1..118] of Byte;
  15.                   end;
  16.   Reply         : Word;
  17.   NovRegs       : Registers;
  18.   Incr          : Word;
  19.   Index         : Byte;
  20. begin
  21.   with RequestBuffer do begin
  22.     SubF   := SubFAddObjToSet;
  23.     ObjT   := Swap(ObjType);
  24.     Index  := 1;
  25.     Incr   := Succ(Length(ObjName));
  26.     Move(ObjName,Buf[Index],Incr);
  27.     Inc(Index,Incr);
  28.  
  29.     Incr   := Succ(Length(PropertyName));
  30.     Move(PropertyName,Buf[Index],Incr);
  31.     Inc(Index,Incr);
  32.     MemberObjType := Swap(MemberObjType);
  33.     Move(MemberObjType,Buf[Index],SizeOf(Word));
  34.     Inc(Index,SizeOf(Word));
  35.     Incr   := Succ(Length(MemberObjName));
  36.     Move(MemberObjName,Buf[Index],Incr);
  37.     Inc(Index,Incr);
  38.     Len := Index + 2; {3?}
  39.   end;
  40.   Reply := 0;
  41.   with NovRegs do begin
  42.     AH := BinderyFunc;
  43.     DS := Seg(RequestBuffer);
  44.     SI := Ofs(RequestBuffer);
  45.     ES := Seg(Reply);
  46.     DI := Ofs(Reply);
  47.     MsDos(NovRegs);
  48.     AddObjectToSet := AL;
  49.   end;
  50. end;
  51.  
  52. function ChangePassword(ObjType : Word; ObjName : ObjNameStr;
  53.                         OldPassword, NewPassword : PasswordStr) : Byte;
  54.  
  55. const
  56.   BufSize = (SizeOf(PasswordStr) * 2) + SizeOf(ObjNameStr);
  57. var
  58.   Request : record
  59.               Len     : Word;
  60.               SubF    : Byte;
  61.               ObjT    : Word;
  62.               Buf     : Array[1..BufSize] of Byte;
  63.             end;
  64.   Reply   : Word;
  65.   NovRegs : Registers;
  66.   Incr    : Word;
  67.   Index   : Word;
  68.  
  69. begin
  70.   with Request do begin
  71.     SubF   := SubFChangeObjPass;
  72.     ObjT   := Swap(ObjType);
  73.     Index  := 1;
  74.     Incr   := Succ(Length(ObjName));
  75.     Move(ObjName,Buf[Index],Incr);
  76.     Inc(Index,Incr);
  77.  
  78.     Incr   := Succ(Length(OldPassword));
  79.     Move(OldPassword,Buf[Index],Incr);
  80.     Inc(Index,Incr);
  81.     Incr   := Succ(Length(NewPassword));
  82.     Move(NewPassword,Buf[Index],Incr);
  83.     Inc(Index,Incr);
  84.     Len := Index + 2; {3?}
  85.   end;
  86.   Reply := 0;
  87.   with NovRegs do begin
  88.     AH := BinderyFunc;
  89.     DS := Seg(Request);
  90.     SI := Ofs(Request);
  91.     ES := Seg(Reply);
  92.     DI := Ofs(Reply);
  93.     MsDos(NovRegs);
  94.     ChangePassword := AL;
  95.   end;
  96. end;
  97.  
  98. function ChangeObjectSecurity(ObjType : Word; ObjName : ObjNameStr;
  99.                               NewSecurity : Byte) : Byte;
  100.  
  101. var
  102.   Request : record
  103.               Len     : Word;
  104.               SubF    : Byte;
  105.               NewSec  : Byte;
  106.               ObjT    : Word;
  107.               ObjN    : ObjNameStr;
  108.             end;
  109.   Reply   : Word;
  110.   NovRegs : Registers;
  111.  
  112. begin
  113.   with Request do begin
  114.     Len     := Length(ObjName) + 4;
  115.     SubF    := SubFChangeObjSec;
  116.     NewSec  := NewSecurity;
  117.     ObjT    := Swap(ObjType);
  118.     ObjN    := ObjName;
  119.   end;
  120.   Reply := 0;
  121.   with NovRegs do begin
  122.     AH := BinderyFunc;
  123.     DS := Seg(Request);
  124.     SI := Ofs(Request);
  125.     ES := Seg(Reply);
  126.     DI := Ofs(Reply);
  127.     MsDos(NovRegs);
  128.     ChangeObjectSecurity := AL;
  129.   end;
  130. end;
  131.  
  132. function ChangePropertySecurity(ObjType : Word; ObjName : ObjNameStr;
  133.                                 PropertyName : PropertyStr;
  134.                                 NewPropertySecurity : Byte) : Byte;
  135.  
  136.  
  137. const
  138.   BufSize = SizeOf(ObjNameStr) + SizeOf(PropertyStr) + SizeOf(Byte);
  139. var
  140.   Request : record
  141.               Len     : Word;
  142.               SubF    : Byte;
  143.               ObjT    : Word;
  144.               Buf     : Array[1..BufSize] of Byte;
  145.             end;
  146.   Reply   : Word;
  147.   NovRegs : Registers;
  148.   Incr    : Word;
  149.   Index   : Word;
  150.  
  151. begin
  152.   with Request do begin
  153.     SubF   := SubFChangePropSec;
  154.     ObjT   := Swap(ObjType);
  155.     Index  := 1;
  156.     Incr   := Succ(Length(ObjName));
  157.     Move(ObjName,Buf[Index],Incr);
  158.     Inc(Index,Incr);
  159.     Buf[Index] := NewPropertySecurity;
  160.     Inc(Index);
  161.  
  162.     Incr   := Succ(Length(PropertyName));
  163.     Move(PropertyName,Buf[Index],Incr);
  164.     Inc(Index,Incr);
  165.     Len := Index + 2; {3?}
  166.   end;
  167.   Reply := 0;
  168.   with NovRegs do begin
  169.     AH := BinderyFunc;
  170.     DS := Seg(Request);
  171.     SI := Ofs(Request);
  172.     ES := Seg(Reply);
  173.     DI := Ofs(Reply);
  174.     MsDos(NovRegs);
  175.     ChangePropertySecurity := AL;
  176.   end;
  177. end;
  178.  
  179. function CloseBindery : Boolean;
  180.  
  181. var
  182.   Request : record
  183.               Len  : Word;
  184.               SubF : Byte;
  185.             end;
  186.   Reply   : Word;
  187.   NovRegs : Registers;
  188.  
  189. begin
  190.   with Request do begin
  191.     Len  := 1;
  192.     SubF := SubFCloseBindery;
  193.   end;
  194.   Reply := 0;
  195.   with NovRegs do begin
  196.     AH := BinderyFunc;
  197.     DS := Seg(Request);
  198.     SI := Ofs(Request);
  199.     ES := Seg(Reply);
  200.     DI := Ofs(Reply);
  201.     MsDos(NovRegs);
  202.     CloseBindery := AL = 0;
  203.   end;
  204. end;
  205.  
  206. function CreateObject(ObjType : Word; ObjName : ObjNameStr;
  207.                       DynamicObj : Boolean;
  208.                       ObjSecurity : Byte) : Byte;
  209. var
  210.   Request : record
  211.               Len    : Word;
  212.               SubF   : Byte;
  213.               ObjF   : Boolean;
  214.               ObjSec : Byte;
  215.               ObjT   : Word;
  216.               ObjN   : ObjNameStr;
  217.             end;
  218.   Reply   : Word;
  219.   NovRegs : Registers;
  220.  
  221. begin
  222.   with Request do begin
  223.     Len     := Length(ObjName) + 6;
  224.     SubF    := SubFCreateObj;
  225.     ObjF    := DynamicObj;
  226.     ObjSec  := ObjSecurity;
  227.     ObjT    := Swap(ObjType);
  228.     ObjN    := ObjName;
  229.   end;
  230.   Reply := 0;
  231.   with NovRegs do begin
  232.     AH := BinderyFunc;
  233.     DS := Seg(Request);
  234.     SI := Ofs(Request);
  235.     ES := Seg(Reply);
  236.     DI := Ofs(Reply);
  237.     MsDos(NovRegs);
  238.     CreateObject := AL;
  239.   end;
  240. end;
  241.  
  242. function CreateProperty(ObjType : Word; ObjName : ObjNameStr;
  243.                         PropertyName : PropertyStr;
  244.                         DynamicProp, SetProp : Boolean;
  245.                         PropertySecurity : Byte) : Byte;
  246. const
  247.   BufSize = SizeOf(ObjNameStr) + (SizeOf(Byte) * 2) + SizeOf(PropertyStr);
  248. var
  249.   Request : record
  250.               Len    : Word;
  251.               SubF   : Byte;
  252.               ObjT   : Word;
  253.               Buf    : Array[1..BufSize] of Byte;
  254.             end;
  255.   Reply   : Word;
  256.   NovRegs : Registers;
  257.   Incr    : Word;
  258.   Index   : Word;
  259. begin
  260.   with Request do begin
  261.     SubF   := SubFCreateProp;
  262.     ObjT   := Swap(ObjType);
  263.     Index  := 1;
  264.     Incr   := Succ(Length(ObjName));
  265.     Move(ObjName,Buf[Index],Incr);
  266.     Inc(Index,Incr);
  267.     Buf[Index] := (Ord(SetProp) shl 1) + Ord(DynamicProp);
  268.     Inc(Index);
  269.     Buf[Index] := PropertySecurity;
  270.     Inc(Index);
  271.     Incr   := Succ(Length(PropertyName));
  272.     Move(PropertyName,Buf[Index],Incr);
  273.     Inc(Index,Incr);
  274.     Len := Index + 2; {3?}
  275.   end;
  276.   Reply := 0;
  277.   with NovRegs do begin
  278.     AH := BinderyFunc;
  279.     DS := Seg(Request);
  280.     SI := Ofs(Request);
  281.     ES := Seg(Reply);
  282.     DI := Ofs(Reply);
  283.     MsDos(NovRegs);
  284.     CreateProperty := AL;
  285.   end;
  286. end;
  287.  
  288. function DeleteObject(ObjType : Word; ObjName : ObjNameStr) : Byte;
  289. var
  290.   Request : record
  291.               Len    : Word;
  292.               SubF   : Byte;
  293.               ObjT   : Word;
  294.               ObjN   : ObjNameStr;
  295.             end;
  296.   Reply   : Word;
  297.   NovRegs : Registers;
  298.  
  299. begin
  300.   with Request do begin
  301.     Len     := Length(ObjName) + 4;
  302.     SubF    := SubFDeleteObj;
  303.     ObjT    := Swap(ObjType);
  304.     ObjN    := ObjName;
  305.   end;
  306.   Reply := 0;
  307.   with NovRegs do begin
  308.     AH := BinderyFunc;
  309.     DS := Seg(Request);
  310.     SI := Ofs(Request);
  311.     ES := Seg(Reply);
  312.     DI := Ofs(Reply);
  313.     MsDos(NovRegs);
  314.     DeleteObject := AL;
  315.   end;
  316. end;
  317.  
  318. function DeleteObjectFromSet(ObjType : Word; ObjName : ObjNameStr;
  319.                              PropertyName : PropertyStr;
  320.                              MemberObjType : Word;
  321.                              MemberName : ObjNameStr) : Byte;
  322.  
  323. const
  324.   BufSize = (SizeOf(ObjNameStr) * 2) + SizeOf(Word) + SizeOf(PropertyStr);
  325. var
  326.   Request : record
  327.               Len    : Word;
  328.               SubF   : Byte;
  329.               ObjT   : Word;
  330.               Buf    : Array[1..BufSize] of Byte;
  331.             end;
  332.   Reply   : Word;
  333.   NovRegs : Registers;
  334.   Incr    : Word;
  335.   Index   : Word;
  336. begin
  337.   with Request do begin
  338.     SubF   := SubFDeleteObjFromSet;
  339.     ObjT   := Swap(ObjType);
  340.     Index  := 1;
  341.     Incr   := Succ(Length(ObjName));
  342.     Move(ObjName,Buf[Index],Incr);
  343.     Inc(Index,Incr);
  344.     Incr   := Succ(Length(PropertyName));
  345.     Move(PropertyName,Buf[Index],Incr);
  346.     Inc(Index,Incr);
  347.     MemberObjType := Swap(MemberObjType);
  348.     Move(MemberObjType,Buf[Index],SizeOf(Word));
  349.     Inc(Index,SizeOf(Word));
  350.     Incr   := Succ(Length(MemberName));
  351.     Move(MemberName,Buf[Index],Incr);
  352.     Inc(Index,Incr);
  353.  
  354.     Len := Index + 2; {3?}
  355.   end;
  356.   Reply := 0;
  357.   with NovRegs do begin
  358.     AH := BinderyFunc;
  359.     DS := Seg(Request);
  360.     SI := Ofs(Request);
  361.     ES := Seg(Reply);
  362.     DI := Ofs(Reply);
  363.     MsDos(NovRegs);
  364.     DeleteObjectFromSet := AL;
  365.   end;
  366. end;
  367.  
  368. function DeleteProperty(ObjType : Word; ObjName : ObjNameStr;
  369.                         PropertyName : PropertyStr) : Byte;
  370.  
  371. const
  372.   BufSize = SizeOf(ObjNameStr) + SizeOf(PropertyStr);
  373.  
  374. var
  375.   Request : record
  376.               Len    : Word;
  377.               SubF   : Byte;
  378.               ObjT   : Word;
  379.               Buf    : Array[1..BufSize] of Byte;
  380.             end;
  381.   Reply   : Word;
  382.   NovRegs : Registers;
  383.   Incr    : Word;
  384.   Index   : Word;
  385.  
  386. begin
  387.   with Request do begin
  388.     SubF   := SubFDeleteProp;
  389.     ObjT   := Swap(ObjType);
  390.     Index  := 1;
  391.     Incr   := Succ(Length(ObjName));
  392.     Move(ObjName,Buf[Index],Incr);
  393.     Inc(Index,Incr);
  394.     Incr   := Succ(Length(PropertyName));
  395.     Move(PropertyName,Buf[Index],Incr);
  396.     Inc(Index,Incr);
  397.  
  398.     Len := Index + 2; {3?}
  399.   end;
  400.   Reply := 0;
  401.   with NovRegs do begin
  402.     AH := BinderyFunc;
  403.     DS := Seg(Request);
  404.     SI := Ofs(Request);
  405.     ES := Seg(Reply);
  406.     DI := Ofs(Reply);
  407.     MsDos(NovRegs);
  408.     DeleteProperty := AL;
  409.   end;
  410. end;
  411.  
  412. function GetBinderyAccessLevel(var AccessLevel : Byte;
  413.                                var ObjectID : LongInt) : Byte;
  414.  
  415. var
  416.   Request   : record
  417.                 Len    : Word;
  418.                 SubF   : Byte;
  419.               end;
  420.   Reply     : record
  421.                 Len    : Word;
  422.                 Level  : Byte;
  423.                 ID     : LongInt;
  424.               end;
  425.   NovRegs   : Registers;
  426.  
  427. begin
  428.   with Request do begin
  429.     Len    := 1;
  430.     SubF   := SubFGetAccessLevel;
  431.   end;
  432.   Reply.Len := SizeOf(Reply) - 2;
  433.   with NovRegs do begin
  434.     AH := BinderyFunc;
  435.     DS := Seg(Request);
  436.     SI := Ofs(Request);
  437.     ES := Seg(Reply);
  438.     DI := Ofs(Reply);
  439.     MsDos(NovRegs);
  440.     GetBinderyAccessLevel := AL;
  441.   end;
  442.   with Reply do begin
  443.     AccessLevel := Level;
  444.     ObjectID    := NetWareSwapLong(ID);
  445.   end;
  446. end;
  447.  
  448. function GetObjectID(var ObjType : Word; var ObjName : ObjNameStr;
  449.                      var ObjID : LongInt) : Byte;
  450. var
  451.   Request   : record
  452.                 Len    : Word;
  453.                 SubF   : Byte;
  454.                 ObjT   : Word;
  455.                 ObjN   : ObjNameStr;
  456.               end;
  457.   Reply     : record
  458.                 Len    : Word;
  459.                 ID     : LongInt;
  460.                 ObjT   : Word;
  461.                 ObjN   : ObjNameStr;
  462.               end;
  463.   NovRegs   : Registers;
  464.  
  465. begin
  466.   with Request do begin
  467.     Len    := Length(ObjName) + 4;
  468.     SubF   := SubFGetObjID;
  469.     ObjT   := Swap(ObjType);
  470.     ObjN   := ObjName;
  471.   end;
  472.   Reply.Len := SizeOf(Reply) - 2;
  473.   with NovRegs do begin
  474.     AH := BinderyFunc;
  475.     DS := Seg(Request);
  476.     SI := Ofs(Request);
  477.     ES := Seg(Reply);
  478.     DI := Ofs(Reply);
  479.     MsDos(NovRegs);
  480.     GetObjectID := AL;
  481.   end;
  482.   with Reply do begin
  483.     ObjID   := NetWareSwapLong(ID);
  484.     ObjType := Swap(ObjT);
  485.     ObjName := AsciiZ2Str(ObjN,SizeOf(ObjNameStr)-1);      {!!.23}
  486.   end;
  487. end;
  488.  
  489. function GetObjectName(ObjectID : LongInt;
  490.                        var ObjType : Word;
  491.                        var ObjName : ObjNameStr) : Byte;
  492.  
  493. var
  494.   Request   : record
  495.                 Len    : Word;
  496.                 SubF   : Byte;
  497.                 ID     : LongInt;
  498.               end;
  499.   Reply     : record
  500.                 Len    : Word;
  501.                 ID     : LongInt;
  502.                 ObjT   : Word;
  503.                 ObjN   : ObjNameStr;
  504.               end;
  505.   NovRegs   : Registers;
  506.  
  507. begin
  508.   with Request do begin
  509.     Len    := SizeOf(Request) - 2;
  510.     SubF   := SubFGetObjName;
  511.     ID     := NetWareSwapLong(ObjectID);
  512.   end;
  513.   Reply.Len := SizeOf(Reply) - 2;
  514.   with NovRegs do begin
  515.     AH := BinderyFunc;
  516.     DS := Seg(Request);
  517.     SI := Ofs(Request);
  518.     ES := Seg(Reply);
  519.     DI := Ofs(Reply);
  520.     MsDos(NovRegs);
  521.     GetObjectName := AL;
  522.   end;
  523.   with Reply do begin
  524.     ObjType := Swap(ObjT);
  525.     ObjName := AsciiZ2Str(ObjN,SizeOf(ObjNameStr)-1);
  526.   end;
  527. end;
  528.  
  529. function IsObjectInSet(ObjType : Word; ObjName : ObjNameStr;
  530.                        PropertyName  : PropertyStr;
  531.                        MemberObjType : Word;
  532.                        MemberName    : ObjNameStr) : Byte;
  533.   {-Returns 0 as function result if member is in set}
  534. const
  535.   BufSize = (SizeOf(ObjNameStr) * 2) + SizeOf(Word) + SizeOf(PropertyStr);
  536.  
  537. var
  538.   Request : record
  539.               Len    : Word;
  540.               SubF   : Byte;
  541.               ObjT   : Word;
  542.               Buf    : Array[1..BufSize] of Byte;
  543.             end;
  544.   Reply   : Word;
  545.   NovRegs : Registers;
  546.   Incr    : Word;
  547.   Index   : Word;
  548.  
  549. begin
  550.   with Request do begin
  551.     SubF   := SubFIsObjInSet;
  552.     ObjT   := Swap(ObjType);
  553.     Index  := 1;
  554.     Incr   := Succ(Length(ObjName));
  555.     Move(ObjName,Buf[Index],Incr);
  556.     Inc(Index,Incr);
  557.     Incr   := Succ(Length(PropertyName));
  558.     Move(PropertyName,Buf[Index],Incr);
  559.     Inc(Index,Incr);
  560.     MemberObjType := Swap(MemberObjType);
  561.     Move(MemberObjType,Buf[Index],SizeOf(Word));
  562.     Inc(Index,SizeOf(Word));
  563.     Incr   := Succ(Length(MemberName));
  564.     Move(MemberName,Buf[Index],Incr);
  565.     Inc(Index,Incr);
  566.     Len := Index + 2; {3?}
  567.   end;
  568.   Reply := 0;
  569.   with NovRegs do begin
  570.     AH := BinderyFunc;
  571.     DS := Seg(Request);
  572.     SI := Ofs(Request);
  573.     ES := Seg(Reply);
  574.     DI := Ofs(Reply);
  575.     MsDos(NovRegs);
  576.     IsObjectInSet := AL;
  577.   end;
  578. end;
  579.  
  580. function OpenBindery : Boolean;
  581.  
  582. var
  583.   Request : record
  584.               Len  : Word;
  585.               SubF : Byte;
  586.             end;
  587.   Reply   : Word;
  588.   NovRegs : Registers;
  589.  
  590. begin
  591.   with Request do begin
  592.     Len  := 1;
  593.     SubF := SubFOpenBindery;
  594.   end;
  595.   Reply := 0;
  596.   with NovRegs do begin
  597.     AH := BinderyFunc;
  598.     DS := Seg(Request);
  599.     SI := Ofs(Request);
  600.     ES := Seg(Reply);
  601.     DI := Ofs(Reply);
  602.     MsDos(NovRegs);
  603.     OpenBindery := AL = 0;
  604.   end;
  605. end;
  606.  
  607. function ReadPropertyValue(ObjType : Word; ObjName : ObjNameStr;
  608.                            SegmentNumber : Byte;
  609.                            PropertyName  : PropertyStr;
  610.                            var PropertyValue : PropertyValueType;
  611.                            var PropertyFlags : Byte;
  612.                            var MoreSegments  : Boolean) : Byte;
  613.  
  614. const
  615.   BufSize = SizeOf(ObjNameStr) + SizeOf(Byte) + SizeOf(PropertyStr);
  616.  
  617. var
  618.   Request : record
  619.               Len    : Word;
  620.               SubF   : Byte;
  621.               ObjT   : Word;
  622.               Buf    : Array[1..BufSize] of Byte;
  623.             end;
  624.   Reply   : record
  625.               Len    : Word;
  626.               PVal   : PropertyValueType;
  627.               More   : Byte;
  628.               PFlags : Byte;
  629.             end;
  630.   NovRegs : Registers;
  631.   Incr    : Word;
  632.   Index   : Word;
  633.  
  634. begin
  635.   with Request do begin
  636.     SubF   := SubFReadPropVal;
  637.     ObjT   := Swap(ObjType);
  638.     Index  := 1;
  639.     Incr   := Succ(Length(ObjName));
  640.     Move(ObjName,Buf[Index],Incr);
  641.     Inc(Index,Incr);
  642.     Buf[Index] := SegmentNumber;
  643.     Inc(Index);
  644.     Incr   := Succ(Length(PropertyName));
  645.     Move(PropertyName,Buf[Index],Incr);
  646.     Inc(Index,Incr);
  647.     Len := Index + 2; {3?}
  648.   end;
  649.   Reply.Len := SizeOf(Reply) - 2;
  650.   with NovRegs do begin
  651.     AH := BinderyFunc;
  652.     DS := Seg(Request);
  653.     SI := Ofs(Request);
  654.     ES := Seg(Reply);
  655.     DI := Ofs(Reply);
  656.     MsDos(NovRegs);
  657.     ReadPropertyValue := AL;
  658.   end;
  659.   with Reply do begin
  660.     PropertyValue := PVal;
  661.     MoreSegments  := More <> 0;
  662.     PropertyFlags := PFlags;
  663.   end;
  664. end;
  665.  
  666. function RenameObject(ObjType : Word;
  667.                       OldObjName, NewObjName : ObjNameStr) : Byte;
  668.  
  669. const
  670.   BufSize = SizeOf(ObjNameStr) * 2;
  671.  
  672. var
  673.   Request : record
  674.               Len    : Word;
  675.               SubF   : Byte;
  676.               ObjT   : Word;
  677.               Buf    : Array[1..BufSize] of Byte;
  678.             end;
  679.   Reply   : Word;
  680.   NovRegs : Registers;
  681.   Incr    : Word;
  682.   Index   : Word;
  683.  
  684. begin
  685.   with Request do begin
  686.     SubF   := SubFRenameObj;
  687.     ObjT   := Swap(ObjType);
  688.     Index  := 1;
  689.     Incr   := Succ(Length(OldObjName));
  690.     Move(OldObjName,Buf[Index],Incr);
  691.     Inc(Index,Incr);
  692.     Incr   := Succ(Length(NewObjName));
  693.     Move(NewObjName,Buf[Index],Incr);
  694.     Inc(Index,Incr);
  695.     Len := Index + 2; {3?}
  696.   end;
  697.   Reply := 0;
  698.   with NovRegs do begin
  699.     AH := BinderyFunc;
  700.     DS := Seg(Request);
  701.     SI := Ofs(Request);
  702.     ES := Seg(Reply);
  703.     DI := Ofs(Reply);
  704.     MsDos(NovRegs);
  705.     RenameObject := AL;
  706.   end;
  707. end;
  708.  
  709. function ScanObject(var ObjType       : Word;
  710.                     var ObjName       : ObjNameStr;
  711.                     var ObjID         : LongInt;
  712.                     var ObjFlag       : Byte;
  713.                     var ObjSecurity   : Byte;
  714.                     var HasProperties : Boolean) : Byte;
  715. const
  716.   ReplyBSize = SizeOf(ObjNameStr) + (SizeOf(Byte) * 3);
  717.  
  718. var
  719.   Request : record
  720.               Len    : Word;
  721.               SubF   : Byte;
  722.               LastID : LongInt;
  723.               ObjT   : Word;
  724.               ObjN   : ObjNameStr;
  725.             end;
  726.   Reply   : record
  727.               Len    : Word;
  728.               ID     : LongInt;
  729.               ObjT   : Word;
  730.               ObjN   : ObjNameField;
  731.               ObjF   : Byte;
  732.               ObjSec : Byte;
  733.               HasProp: Byte;
  734.             end;
  735.   NovRegs : Registers;
  736.   Index   : Word;
  737.   L       : Word;
  738.  
  739. begin
  740.   with Request do begin
  741.     SubF   := SubFScanObj;
  742.     LastID := NetWareSwapLong(ObjID);
  743.     ObjT   := Swap(ObjType);
  744.     ObjN   := ObjName;
  745.     Len    := Length(ObjName) + 8;
  746.   end;
  747.   Reply.Len := SizeOf(Reply) - 2;
  748.   with NovRegs do begin
  749.     AH := BinderyFunc;
  750.     DS := Seg(Request);
  751.     SI := Ofs(Request);
  752.     ES := Seg(Reply);
  753.     DI := Ofs(Reply);
  754.     MsDos(NovRegs);
  755.     ScanObject := AL;
  756.     if AL = 0 then
  757.       with Reply do begin
  758.         ObjID         := NetWareSwapLong(ID);
  759.         ObjType       := Swap(ObjT);
  760.         ObjName       := AsciiZ2Str(ObjN,SizeOf(ObjNameStr)-1);
  761.         ObjFlag       := ObjF;
  762.         ObjSecurity   := ObjSec;
  763.         HasProperties := HasProp <> 0;
  764.       end;
  765.   end;
  766. end;
  767.  
  768. function ScanProperty(ObjType : Word; ObjName : ObjNameStr;
  769.                       var Sequence : LongInt;
  770.                       var PropertyName : PropertyStr;
  771.                       var PropertyFlags, PropertySecurity : Byte;
  772.                       var HasValue, MoreProperties : Boolean) : Byte;
  773.  
  774. const
  775.   BufSize = SizeOf(ObjNameStr) + SizeOf(LongInt) + SizeOf(PropertyStr);
  776. var
  777.   Request : record
  778.               Len    : Word;
  779.               SubF   : Byte;
  780.               ObjT   : Word;
  781.               Buf    : Array[1..BufSize] of Byte;
  782.             end;
  783.   Reply   : record
  784.               Len      : Word;
  785.               PropN    : PropertyField;
  786.               PropF    : Byte;
  787.               PropSec  : Byte;
  788.               SeqNum   : LongInt;
  789.               HasVal   : Byte;
  790.               More     : Byte;
  791.             end;
  792.   NovRegs : Registers;
  793.   Index   : Word;
  794.   Incr    : Word;
  795.  
  796. begin
  797.   with Request do begin
  798.     SubF   := SubFScanProp;
  799.     ObjT   := Swap(ObjType);
  800.     Index  := 1;
  801.     Incr   := Succ(Length(ObjName));
  802.     Move(ObjName,Buf[Index],Incr);
  803.     Inc(Index,Incr);
  804.     Move(Sequence,Buf[Index],SizeOf(LongInt));
  805.     Inc(Index,SizeOf(LongInt));
  806.     Incr   := Succ(Length(PropertyName));
  807.     Move(PropertyName,Buf[Index],Incr);
  808.     Inc(Index,Incr);
  809.     Len := Index + 2; {3?}
  810.   end;
  811.   Reply.Len := SizeOf(Reply) - 2;
  812.   with NovRegs do begin
  813.     AH := BinderyFunc;
  814.     DS := Seg(Request);
  815.     SI := Ofs(Request);
  816.     ES := Seg(Reply);
  817.     DI := Ofs(Reply);
  818.     MsDos(NovRegs);
  819.     ScanProperty := AL;
  820.     if AL = 0 then
  821.       with Reply do begin
  822.         PropertyName     := AsciiZ2Str(PropN,SizeOf(PropertyStr) - 1);
  823.         PropertyFlags    := PropF;
  824.         PropertySecurity := PropSec;
  825.         Sequence         := SeqNum;
  826.         HasValue         := HasVal <> 0;
  827.         MoreProperties   := More <> 0;
  828.       end
  829.     else begin
  830.       HasValue         := False;
  831.       MoreProperties   := False;
  832.     end;
  833.   end;
  834. end;
  835.  
  836. function VerifyPassword(ObjType : Word; ObjName : ObjNameStr;
  837.                         Password : PasswordStr) : Byte;
  838.  
  839. const
  840.   BufSize = SizeOf(PasswordStr) + SizeOf(ObjNameStr);
  841. var
  842.   Request : record
  843.               Len     : Word;
  844.               SubF    : Byte;
  845.               ObjT    : Word;
  846.               Buf     : Array[1..BufSize] of Char;
  847.             end;
  848.   Reply   : Word;
  849.   NovRegs : Registers;
  850.   Incr    : Word;
  851.   Index   : Word;
  852.  
  853. begin
  854.   with Request do begin
  855.     SubF   := SubFVerifyPass;
  856.     ObjT   := Swap(ObjType);
  857.     Index  := 1;
  858.     Incr   := Succ(Length(ObjName));
  859.     Move(ObjName,Buf[Index],Incr);
  860.     Inc(Index,Incr);
  861.  
  862.     Incr   := Succ(Length(Password));
  863.     Move(Password,Buf[Index],Incr);
  864.     Inc(Index,Incr);
  865.     Len := Index + 2;
  866.   end;
  867.   Reply := 0;
  868.   with NovRegs do begin
  869.     AH := BinderyFunc;
  870.     DS := Seg(Request);
  871.     SI := Ofs(Request);
  872.     ES := Seg(Reply);
  873.     DI := Ofs(Reply);
  874.     MsDos(NovRegs);
  875.     VerifyPassword := AL;
  876.   end;
  877.  
  878. end;
  879.  
  880.